home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 127 / PC Guia 127.iso / Software / Produtividade / OpenOffice.org 2.0.1 / openofficeorg3.cab / mailcap.py < prev    next >
Text File  |  2005-11-19  |  7KB  |  256 lines
  1. """Mailcap file handling.  See RFC 1524."""
  2.  
  3. import os
  4.  
  5. __all__ = ["getcaps","findmatch"]
  6.  
  7. # Part 1: top-level interface.
  8.  
  9. def getcaps():
  10.     """Return a dictionary containing the mailcap database.
  11.  
  12.     The dictionary maps a MIME type (in all lowercase, e.g. 'text/plain')
  13.     to a list of dictionaries corresponding to mailcap entries.  The list
  14.     collects all the entries for that MIME type from all available mailcap
  15.     files.  Each dictionary contains key-value pairs for that MIME type,
  16.     where the viewing command is stored with the key "view".
  17.  
  18.     """
  19.     caps = {}
  20.     for mailcap in listmailcapfiles():
  21.         try:
  22.             fp = open(mailcap, 'r')
  23.         except IOError:
  24.             continue
  25.         morecaps = readmailcapfile(fp)
  26.         fp.close()
  27.         for key, value in morecaps.iteritems():
  28.             if not key in caps:
  29.                 caps[key] = value
  30.             else:
  31.                 caps[key] = caps[key] + value
  32.     return caps
  33.  
  34. def listmailcapfiles():
  35.     """Return a list of all mailcap files found on the system."""
  36.     # XXX Actually, this is Unix-specific
  37.     if 'MAILCAPS' in os.environ:
  38.         str = os.environ['MAILCAPS']
  39.         mailcaps = str.split(':')
  40.     else:
  41.         if 'HOME' in os.environ:
  42.             home = os.environ['HOME']
  43.         else:
  44.             # Don't bother with getpwuid()
  45.             home = '.' # Last resort
  46.         mailcaps = [home + '/.mailcap', '/etc/mailcap',
  47.                 '/usr/etc/mailcap', '/usr/local/etc/mailcap']
  48.     return mailcaps
  49.  
  50.  
  51. # Part 2: the parser.
  52.  
  53. def readmailcapfile(fp):
  54.     """Read a mailcap file and return a dictionary keyed by MIME type.
  55.  
  56.     Each MIME type is mapped to an entry consisting of a list of
  57.     dictionaries; the list will contain more than one such dictionary
  58.     if a given MIME type appears more than once in the mailcap file.
  59.     Each dictionary contains key-value pairs for that MIME type, where
  60.     the viewing command is stored with the key "view".
  61.     """
  62.     caps = {}
  63.     while 1:
  64.         line = fp.readline()
  65.         if not line: break
  66.         # Ignore comments and blank lines
  67.         if line[0] == '#' or line.strip() == '':
  68.             continue
  69.         nextline = line
  70.         # Join continuation lines
  71.         while nextline[-2:] == '\\\n':
  72.             nextline = fp.readline()
  73.             if not nextline: nextline = '\n'
  74.             line = line[:-2] + nextline
  75.         # Parse the line
  76.         key, fields = parseline(line)
  77.         if not (key and fields):
  78.             continue
  79.         # Normalize the key
  80.         types = key.split('/')
  81.         for j in range(len(types)):
  82.             types[j] = types[j].strip()
  83.         key = '/'.join(types).lower()
  84.         # Update the database
  85.         if key in caps:
  86.             caps[key].append(fields)
  87.         else:
  88.             caps[key] = [fields]
  89.     return caps
  90.  
  91. def parseline(line):
  92.     """Parse one entry in a mailcap file and return a dictionary.
  93.  
  94.     The viewing command is stored as the value with the key "view",
  95.     and the rest of the fields produce key-value pairs in the dict.
  96.     """
  97.     fields = []
  98.     i, n = 0, len(line)
  99.     while i < n:
  100.         field, i = parsefield(line, i, n)
  101.         fields.append(field)
  102.         i = i+1 # Skip semicolon
  103.     if len(fields) < 2:
  104.         return None, None
  105.     key, view, rest = fields[0], fields[1], fields[2:]
  106.     fields = {'view': view}
  107.     for field in rest:
  108.         i = field.find('=')
  109.         if i < 0:
  110.             fkey = field
  111.             fvalue = ""
  112.         else:
  113.             fkey = field[:i].strip()
  114.             fvalue = field[i+1:].strip()
  115.         if fkey in fields:
  116.             # Ignore it
  117.             pass
  118.         else:
  119.             fields[fkey] = fvalue
  120.     return key, fields
  121.  
  122. def parsefield(line, i, n):
  123.     """Separate one key-value pair in a mailcap entry."""
  124.     start = i
  125.     while i < n:
  126.         c = line[i]
  127.         if c == ';':
  128.             break
  129.         elif c == '\\':
  130.             i = i+2
  131.         else:
  132.             i = i+1
  133.     return line[start:i].strip(), i
  134.  
  135.  
  136. # Part 3: using the database.
  137.  
  138. def findmatch(caps, MIMEtype, key='view', filename="/dev/null", plist=[]):
  139.     """Find a match for a mailcap entry.
  140.  
  141.     Return a tuple containing the command line, and the mailcap entry
  142.     used; (None, None) if no match is found.  This may invoke the
  143.     'test' command of several matching entries before deciding which
  144.     entry to use.
  145.  
  146.     """
  147.     entries = lookup(caps, MIMEtype, key)
  148.     # XXX This code should somehow check for the needsterminal flag.
  149.     for e in entries:
  150.         if 'test' in e:
  151.             test = subst(e['test'], filename, plist)
  152.             if test and os.system(test) != 0:
  153.                 continue
  154.         command = subst(e[key], MIMEtype, filename, plist)
  155.         return command, e
  156.     return None, None
  157.  
  158. def lookup(caps, MIMEtype, key=None):
  159.     entries = []
  160.     if MIMEtype in caps:
  161.         entries = entries + caps[MIMEtype]
  162.     MIMEtypes = MIMEtype.split('/')
  163.     MIMEtype = MIMEtypes[0] + '/*'
  164.     if MIMEtype in caps:
  165.         entries = entries + caps[MIMEtype]
  166.     if key is not None:
  167.         entries = filter(lambda e, key=key: key in e, entries)
  168.     return entries
  169.  
  170. def subst(field, MIMEtype, filename, plist=[]):
  171.     # XXX Actually, this is Unix-specific
  172.     res = ''
  173.     i, n = 0, len(field)
  174.     while i < n:
  175.         c = field[i]; i = i+1
  176.         if c != '%':
  177.             if c == '\\':
  178.                 c = field[i:i+1]; i = i+1
  179.             res = res + c
  180.         else:
  181.             c = field[i]; i = i+1
  182.             if c == '%':
  183.                 res = res + c
  184.             elif c == 's':
  185.                 res = res + filename
  186.             elif c == 't':
  187.                 res = res + MIMEtype
  188.             elif c == '{':
  189.                 start = i
  190.                 while i < n and field[i] != '}':
  191.                     i = i+1
  192.                 name = field[start:i]
  193.                 i = i+1
  194.                 res = res + findparam(name, plist)
  195.             # XXX To do:
  196.             # %n == number of parts if type is multipart/*
  197.             # %F == list of alternating type and filename for parts
  198.             else:
  199.                 res = res + '%' + c
  200.     return res
  201.  
  202. def findparam(name, plist):
  203.     name = name.lower() + '='
  204.     n = len(name)
  205.     for p in plist:
  206.         if p[:n].lower() == name:
  207.             return p[n:]
  208.     return ''
  209.  
  210.  
  211. # Part 4: test program.
  212.  
  213. def test():
  214.     import sys
  215.     caps = getcaps()
  216.     if not sys.argv[1:]:
  217.         show(caps)
  218.         return
  219.     for i in range(1, len(sys.argv), 2):
  220.         args = sys.argv[i:i+2]
  221.         if len(args) < 2:
  222.             print "usage: mailcap [MIMEtype file] ..."
  223.             return
  224.         MIMEtype = args[0]
  225.         file = args[1]
  226.         command, e = findmatch(caps, MIMEtype, 'view', file)
  227.         if not command:
  228.             print "No viewer found for", type
  229.         else:
  230.             print "Executing:", command
  231.             sts = os.system(command)
  232.             if sts:
  233.                 print "Exit status:", sts
  234.  
  235. def show(caps):
  236.     print "Mailcap files:"
  237.     for fn in listmailcapfiles(): print "\t" + fn
  238.     print
  239.     if not caps: caps = getcaps()
  240.     print "Mailcap entries:"
  241.     print
  242.     ckeys = caps.keys()
  243.     ckeys.sort()
  244.     for type in ckeys:
  245.         print type
  246.         entries = caps[type]
  247.         for e in entries:
  248.             keys = e.keys()
  249.             keys.sort()
  250.             for k in keys:
  251.                 print "  %-15s" % k, e[k]
  252.             print
  253.  
  254. if __name__ == '__main__':
  255.     test()
  256.